
def generate_amortization_schedule(principal, interest_rate, loan_term, extra_payments=[]):
    # Convert interest rate to decimal and calculate periodic interest rate
    monthly_interest_rate = interest_rate / 12 / 100

    # Calculate the number of monthly payments
    num_payments = loan_term * 12

    # Calculate the fixed monthly payment using the amortization formula
    monthly_payment = (principal * monthly_interest_rate) / (1 - (1 + monthly_interest_rate) ** -num_payments)
    monthly_payment = round(monthly_payment, 2)

    # Initialize variables
    remaining_balance = principal
    amortization_schedule = []

    one_time_payment = None
    if extra_payments != []:
        one_time_payment = extra_payments.pop(0)
    for payment_number in range(1, num_payments + 1):
        # Calculate interest for the current period
        if remaining_balance == 0:
            break
        interest_payment = round(remaining_balance * monthly_interest_rate, 2)

        # Calculate principal payment
        principal_payment = round(monthly_payment - interest_payment, 2)

        # Apply one-time payment if provided
        if one_time_payment and payment_number == one_time_payment['payment-number']:
            principal_payment += one_time_payment['amount']
            if extra_payments != []:
                one_time_payment = extra_payments.pop(0)
        # Update remaining balance
        remaining_balance -= principal_payment

        if remaining_balance < 0:
            principal_payment = principal_payment + remaining_balance
            monthly_payment = monthly_payment + remaining_balance
            remaining_balance = 0

        # Create a dictionary with payment details and add it to the amortization schedule
        payment_details = {
            'Payment Number': payment_number,
            'Payment Amount': round(monthly_payment,2),
            'Interest Payment': interest_payment,
            'Principal Payment': round(principal_payment,2),
            'Remaining Balance': round(remaining_balance,2)
        }
        amortization_schedule.append(payment_details)
    return amortization_schedule

def get_totals(amortization_schedule, func=None):
    total_paid = 0
    total_interest_paid = 0
    total_principal_paid = 0
    # Display the amortization schedule
    messages = []
    for payment in amortization_schedule:
        # print(payment)
        total_paid += payment["Payment Amount"]
        total_interest_paid += payment["Interest Payment"]
        total_principal_paid += payment["Principal Payment"]  
        if payment["Remaining Balance"] < 0:
            break
        attrs = [payment[key] for key in payment]
        if func is not None:
            messages.append("%s" % ", ".join([str(attr) for attr in attrs]))
    if func is not None:
        func(messages)
    return total_paid, total_interest_paid, total_principal_paid

def compare(with_extra_payments, without):
    x,y,z = get_totals(with_extra_payments)
    a,b,c = get_totals(without)
    term_length = len(without) - len(with_extra_payments)
    print(chr(916), "paid: ", round(x-a,2))
    print(chr(916), "interest paid: ", round(y-b,2))
    print(chr(916), "principal paid: ", round(abs(z-c),2))
    print(chr(916), "term (months): ", term_length)

def display(table):
    print("id, paid, interest payment, principal payment, remaining")
    for row in table:
        print(row)

def export(table, filename="schedule.csv"):
    with open(filename, 'w') as f:
        print("id, paid, interest payment, principal payment, remaining", file=f)
        for row in table:
            print(row, file=f)
    print("wrote to file", filename)

if __name__ == "__main__":
    import argparse, json

    def get_arguments():
        p = argparse.ArgumentParser()
        p. add_argument("--principal", "-p", type=float, \
            help="set value for principal")
        p.add_argument("---interest-rate", "-i", type=float,\
            help="set the value for interest rate (percentage)")
        p.add_argument("--term", "-t", type=int,\
            help="sets the term (years)")
        p.add_argument("--one-time", "-ot", type=str,\
            help="factors in a one-time payment (json, example: {\"payment-number\":13,\"amount\":5000}")
        p.add_argument("--extra-payments", "-ep", type=str,\
            help="facts in multiple one time payments (json file name)")
        args = p.parse_args()
        l = []
        if args.extra_payments is not None:
            with open(args.extra_payments) as f:
                l = json.loads(f.read())
        extra = []
        if "extra-payments" in l:
            extra = l["extra-payments"]
            extra.sort(key=lambda k: k["payment-number"])
        if args.one_time is not None:
            extra.append(json.loads(args.one_time))
        return args.principal, args.interest_rate, args.term, extra

    principal, interest_rate, loan_term, extra_payments = get_arguments()

    schedule = generate_amortization_schedule(principal, interest_rate, loan_term, extra_payments)
    paid, interest_paid, principal_paid = get_totals(schedule,export)

    print("total paid: ", round(paid,2))
    print("total interest paid: ", round(interest_paid,2))
    print("total principal paid: ", round(principal_paid,2))

    # without extra payments for comparison
    compare(schedule, generate_amortization_schedule(
        principal, interest_rate, loan_term)
    )

